const storage = require('../../utils/storage.js');
const imageUtil = require('../../utils/image.js');
const rongcloud = require('../../utils/rongcloud.js');
const messageStorage = require('../../utils/messageStorage.js');

Page({
  data: {
    statusBarHeight: 0,
    navBarHeight: 0,
    inputBoxHeight: 0,
    keyboardHeight: 0,     // 🔥 键盘高度
    friendId: 0,           // 好友ID（数据库ID）
    friendPhone: '',       // 🔥 好友手机号（融云用户ID）
    friendName: '',        // 好友昵称
    friendAvatar: '',      // 好友头像
    userAvatar: '',        // 当前用户头像
    currentUserId: 0,      // 当前用户ID（数据库ID）
    currentUserPhone: '',  // 🔥 当前用户手机号（融云用户ID）
    messages: [],          // 消息列表
    inputText: '',         // 输入框文本
    scrollToView: '',      // 滚动到的位置
    currentTime: '',       // 当前时间
    isConnected: false,    // 融云连接状态
    isSending: false,      // 是否正在发送消息（已废弃，保留兼容性）
  },
  
  // 消息监听器
  messageListener: null,
  // 连接监听器
  connectionListener: null,
  // 🔥 消息发送队列（支持并发发送）
  sendingMessages: new Set(),

  onLoad(options) {
    console.log('💬 =============== 聊天页面加载开始 ===============');
    console.log('📊 接收参数:', options);
    
    // 获取系统状态栏高度
    const windowInfo = wx.getWindowInfo();
    const statusBarHeight = windowInfo.statusBarHeight;
    const navBarHeight = statusBarHeight + 44; // 88rpx ≈ 44px
    
    this.setData({
      statusBarHeight: statusBarHeight,
      navBarHeight: navBarHeight,
      inputBoxHeight: 140, // 底部输入框高度（px）
      currentTime: this.formatCurrentTime()
    });
    
    // 获取好友信息
    if (options.friendId && options.friendName) {
      // 解码头像URL（如果存在）
      const friendAvatar = options.friendAvatar 
        ? decodeURIComponent(options.friendAvatar) 
        : '/images/avatar.png';
      
      // 🔥 获取好友手机号（融云用户ID）
      const friendPhone = options.friendPhone || '';
      
      this.setData({
        friendId: parseInt(options.friendId),
        friendPhone: friendPhone, // 🔥 保存手机号
        friendName: decodeURIComponent(options.friendName),
        friendAvatar: imageUtil.processAvatar(friendAvatar)
      });
      
      console.log('👤 好友信息:');
      console.log('  ID:', this.data.friendId);
      console.log('  📱 手机号（融云用户ID）:', this.data.friendPhone);
      console.log('  昵称:', this.data.friendName);
      console.log('  头像:', this.data.friendAvatar);
      
      // 🔥 检查是否有手机号
      if (!this.data.friendPhone) {
        console.warn('⚠️ 未提供好友手机号，可能无法正常发送消息');
      }
    } else {
      console.error('❌ 缺少必要参数：friendId 或 friendName');
      wx.showToast({
        title: '参数错误',
        icon: 'none',
        duration: 2000
      });
      setTimeout(() => {
        wx.navigateBack();
      }, 2000);
      return;
    }
    
    // 获取当前用户信息
    this.loadCurrentUserInfo();
    
    // 加载历史消息
    this.loadMessages();
  },

  // 加载当前用户信息
  loadCurrentUserInfo() {
    const userInfo = storage.getUserInfo();
    if (userInfo) {
      // 🔥 获取当前用户的手机号（融云用户ID）
      const currentUserPhone = userInfo.userPhone || storage.getUserPhone() || '';
      
      this.setData({
        currentUserId: userInfo.userid,
        currentUserPhone: currentUserPhone, // 🔥 保存手机号
        userAvatar: imageUtil.processAvatar(userInfo.userAvatarUrl)
      });
      console.log('👤 当前用户信息:');
      console.log('  - 数据库ID:', this.data.currentUserId);
      console.log('  - 📱 手机号（融云用户ID）:', this.data.currentUserPhone);
      console.log('  - 头像:', this.data.userAvatar);
      
      // 🔥 检查是否有手机号
      if (!this.data.currentUserPhone) {
        console.warn('⚠️ 未找到当前用户手机号，消息接收可能有问题');
      }
    }
  },

  // 🔥 加载历史消息（优先从本地存储加载，然后从融云同步）
  loadMessages() {
    console.log('📨 =============== 加载历史消息 ===============');
    
    // 🔥 步骤1：先从本地存储加载消息（快速显示）
    // 优先使用数据库ID，如果找不到则尝试使用手机号（兼容旧数据）
    let localMessages = messageStorage.getChatMessages(String(this.data.friendId));
    
    // 🔥 兼容旧数据：如果用数据库ID找不到，尝试用手机号
    if (localMessages.length === 0 && this.data.friendPhone) {
      console.log('📦 尝试用手机号加载旧消息...');
      const oldMessages = messageStorage.getChatMessages(String(this.data.friendPhone));
      if (oldMessages.length > 0) {
        console.log('📦 找到旧消息:', oldMessages.length, '条，迁移到新key');
        // 迁移：用数据库ID重新保存
        messageStorage.saveChatMessages(String(this.data.friendId), oldMessages);
        // 清除旧数据（可选）
        messageStorage.clearChatMessages(String(this.data.friendPhone));
        localMessages = oldMessages;
      }
    }
    
    if (localMessages.length > 0) {
      console.log('📦 从本地加载消息:', localMessages.length, '条');
      this.setData({
        messages: localMessages
      });
      // 滚动到底部
      this.scrollToBottom();
    }
    
    // 🔥 步骤2：检查融云连接状态
    const isConnected = rongcloud.getConnectionStatus();
    this.setData({ isConnected });
    
    if (!isConnected) {
      console.log('⚠️ 融云IM未连接，仅显示本地消息');
      if (localMessages.length === 0) {
        wx.showToast({
          title: '正在连接...',
          icon: 'loading',
          duration: 2000
        });
        
        // 延迟重试
        setTimeout(() => {
          this.loadMessages();
        }, 2000);
      }
      return;
    }
    
    // 🔥 步骤3：从融云服务器同步历史消息
    console.log('✅ 融云IM已连接，同步服务器消息');
    console.log('👤 好友数据库ID:', this.data.friendId);
    console.log('📱 好友融云用户ID（手机号）:', this.data.friendPhone);
    console.log('👤 好友名称:', this.data.friendName);
    
    // 🔥 如果有手机号，使用手机号获取历史消息；否则使用数据库ID（向后兼容）
    const targetId = this.data.friendPhone || String(this.data.friendId);
    console.log('🎯 使用的targetId:', targetId);
    
    rongcloud.getHistoryMessages(targetId, 20, 0)
      .then((result) => {
        console.log('✅ 历史消息同步成功');
        console.log('📦 完整响应:', result);
        console.log('📊 消息数量:', result.list ? result.list.length : 0);
        console.log('🔄 是否还有更多:', result.hasMore);
        
        // 处理消息列表
        const serverMessages = this.processMessages(result.list || []);
        
        // 🔥 保存服务器消息到本地存储
        if (serverMessages.length > 0) {
          messageStorage.saveChatMessages(String(this.data.friendId), serverMessages);
          
          // 服务器有消息，使用服务器消息（更完整）
          this.setData({
            messages: serverMessages
          });
          
          // 滚动到底部
          this.scrollToBottom();
          
          console.log('✅ 历史消息同步完成，使用服务器消息:', serverMessages.length, '条');
        } else {
          // 🔥 服务器返回空列表，保留本地消息（不覆盖）
          console.log('ℹ️ 服务器暂无历史消息，保留本地消息:', localMessages.length, '条');
          
          // 如果本地也没有消息，才设置为空
          if (localMessages.length === 0) {
            this.setData({
              messages: []
            });
          }
          // 否则保留本地消息，不做任何操作
        }
        
        console.log('✅ 历史消息加载完成，当前显示:', this.data.messages.length, '条');
      })
      .catch((error) => {
        console.error('❌ 历史消息同步失败:', error);
        console.error('📦 错误详情:', error);
        
        // 如果服务器同步失败，保留本地消息
        if (localMessages.length === 0) {
          this.setData({
            messages: []
          });
        }
      });
  },
  
  // 🔥 处理融云消息列表转换为UI显示格式
  processMessages(rongMessages) {
    const currentUserId = this.data.currentUserId;
    
    return rongMessages.map((msg) => {
      return {
        id: msg.messageId,
        content: msg.content.content, // 融云TextMessage的content.content
        isSelf: msg.senderUserId === String(currentUserId),
        time: this.formatMessageTimeFromTimestamp(msg.sentTime),
        sentTime: msg.sentTime,
        messageType: msg.messageType
      };
    });
  },
  
  // 格式化时间戳为HH:MM
  formatMessageTimeFromTimestamp(timestamp) {
    const date = new Date(timestamp);
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    return `${hours}:${minutes}`;
  },

  // 输入框内容变化
  onInputChange(e) {
    this.setData({
      inputText: e.detail.value
    });
  },

  // 🔥 键盘高度变化监听
  onKeyboardHeightChange(e) {
    const keyboardHeight = e.detail.height || 0;
    console.log('⌨️ 键盘高度变化:', keyboardHeight);
    
    this.setData({
      keyboardHeight: keyboardHeight
    });
    
    // 键盘弹起时，延迟滚动到底部（确保消息可见）
    if (keyboardHeight > 0) {
      setTimeout(() => {
        this.scrollToBottom();
      }, 100);
    }
  },

  // 🔥 输入框获得焦点
  onInputFocus(e) {
    console.log('📝 输入框获得焦点');
    
    // 焦点时滚动到底部
    setTimeout(() => {
      this.scrollToBottom();
    }, 300);
  },

  // 🔥 输入框失去焦点
  onInputBlur(e) {
    console.log('📝 输入框失去焦点');
    
    // 失焦时重置键盘高度
    setTimeout(() => {
      this.setData({
        keyboardHeight: 0
      });
    }, 100);
  },

  // 🔥 发送消息（支持并发，不会丢失消息）
  onSendMessage() {
    const content = this.data.inputText.trim();
    
    if (!content) {
      wx.showToast({
        title: '请输入消息内容',
        icon: 'none',
        duration: 1500
      });
      return;
    }
    
    // 🔥 检查发送队列大小，防止融云限流
    if (this.sendingMessages.size >= 5) {
      wx.showToast({
        title: '发送太快，请稍候',
        icon: 'none',
        duration: 1500
      });
      console.warn('⚠️ 发送队列已满，请稍候');
      return;
    }
    
    // 检查融云连接状态
    if (!this.data.isConnected) {
      console.log('⚠️ 融云未连接，尝试重新连接');
      wx.showToast({
        title: '连接中，请稍候',
        icon: 'none',
        duration: 2000
      });
      
      // 尝试自动连接
      const app = getApp();
      app.autoConnectRongCloud();
      return;
    }
    
    console.log('📤 =============== 发送消息 ===============');
    console.log('👤 接收者数据库ID:', this.data.friendId);
    console.log('📱 接收者融云用户ID（手机号）:', this.data.friendPhone);
    console.log('📝 消息内容:', content);
    console.log('👤 当前用户ID:', this.data.currentUserId);
    console.log('📊 当前发送队列大小:', this.sendingMessages.size); // 🔥 新增日志
    
    // 🔥 检查是否有手机号
    if (!this.data.friendPhone) {
      wx.showToast({
        title: '无法发送消息：缺少好友手机号',
        icon: 'none',
        duration: 2000
      });
      console.error('❌ 无法发送消息：friendPhone为空');
      return;
    }
    
    // 🔥 生成临时消息ID（使用时间戳+随机数，确保唯一性）
    const tempId = 'temp_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
    
    // 🔥 添加到发送队列
    this.sendingMessages.add(tempId);
    console.log('📤 [添加到队列] 消息内容:', content, '| 队列大小:', this.sendingMessages.size, '条'); // 🔥 详细日志
    
    // 先添加到消息列表（显示发送中状态）
    const tempMessage = {
      id: tempId,
      content: content,
      isSelf: true,
      time: this.formatMessageTime(),
      sentTime: Date.now(),
      sending: true, // 发送中标记
      messageType: 'RC:TxtMsg'
    };
    
    const messages = [...this.data.messages, tempMessage];
    
    this.setData({
      messages: messages,
      inputText: '' // 清空输入框
    });
    
    // 滚动到底部
    this.scrollToBottom();
    
    // 🔥 调用融云IM发送消息（并发发送，不阻塞）
    rongcloud.sendTextMessage(String(this.data.friendPhone), content)
      .then((result) => {
        console.log('✅ [发送成功] 消息内容:', content);
        console.log('   📨 消息ID:', result.messageId);
        console.log('   ⏰ 发送时间:', result.sentTime);
        console.log('   📊 剩余队列:', this.sendingMessages.size - 1, '条'); // 🔥 详细日志
        
        // 创建完整的消息对象
        const sentMessage = {
          id: result.messageId,
          content: content,
          isSelf: true,
          time: this.formatMessageTimeFromTimestamp(result.sentTime),
          sentTime: result.sentTime,
          messageType: 'RC:TxtMsg'
        };
        
        // 🔥 保存到本地存储
        messageStorage.saveChatMessage(String(this.data.friendId), sentMessage);
        
        // 🔥 从发送队列中移除
        this.sendingMessages.delete(tempId);
        console.log('   ✅ 已从发送队列移除，当前队列大小:', this.sendingMessages.size, '条');
        
        // 更新消息列表，移除发送中标记
        const updatedMessages = this.data.messages.map((msg) => {
          if (msg.id === tempId) {
            return sentMessage;
          }
          return msg;
        });
        
        this.setData({
          messages: updatedMessages
        });
        
        console.log('   ✅ 消息UI更新完成');
      })
      .catch((error) => {
        console.error('❌ [发送失败] 消息内容:', content);
        console.error('   错误码:', error.code);
        console.error('   错误信息:', error.msg || error.message);
        console.error('   完整错误:', error); // 🔥 新增：打印完整错误对象
        console.error('   当前队列:', this.sendingMessages.size, '条'); // 🔥 详细日志
        
        // 🔥 从发送队列中移除
        this.sendingMessages.delete(tempId);
        console.error('   ❌ 已从队列移除，剩余:', this.sendingMessages.size, '条');
        
        // 🔥 根据错误码给出具体提示
        let errorMsg = '未知错误';
        if (error.code === 23408) {
          errorMsg = '发送频率过快，请稍候再试';
        } else if (error.code === 31004) {
          errorMsg = 'Token无效，请重新登录';
        } else if (error.code === 30003) {
          errorMsg = '服务器错误，请稍后重试';
        } else {
          errorMsg = error.msg || error.message || '发送失败';
        }
        
        // 显示发送失败提示
        wx.showToast({
          title: errorMsg,
          icon: 'none',
          duration: 2000
        });
        
        // 标记消息发送失败
        const updatedMessages = this.data.messages.map((msg) => {
          if (msg.id === tempId) {
            return {
              ...msg,
              sending: false,
              failed: true, // 失败标记
              errorCode: error.code, // 🔥 新增：保存错误码
              errorMsg: errorMsg // 🔥 新增：保存错误信息
            };
          }
          return msg;
        });
        
        this.setData({
          messages: updatedMessages
        });
      });
  },

  // 滚动到底部
  scrollToBottom() {
    this.setData({
      scrollToView: 'bottom-anchor'
    });
  },

  // 格式化当前时间（用于时间分隔线）
  formatCurrentTime() {
    const now = new Date();
    const hours = now.getHours().toString().padStart(2, '0');
    const minutes = now.getMinutes().toString().padStart(2, '0');
    return `${hours}:${minutes}`;
  },

  // 格式化消息时间
  formatMessageTime() {
    const now = new Date();
    const hours = now.getHours().toString().padStart(2, '0');
    const minutes = now.getMinutes().toString().padStart(2, '0');
    return `${hours}:${minutes}`;
  },

  // 显示菜单
  onShowMenu() {
    wx.showActionSheet({
      itemList: ['查看好友信息', '清空聊天记录', '删除好友'],
      success: (res) => {
        switch (res.tapIndex) {
          case 0:
            // 查看好友信息
            console.log('👤 查看好友信息');
            wx.navigateTo({
              url: `/pages/user-info/index?userId=${this.data.friendId}`
            });
            break;
          case 1:
            // 清空聊天记录
            console.log('🗑️ 清空聊天记录');
            wx.showModal({
              title: '提示',
              content: '确定要清空聊天记录吗？',
              success: (modalRes) => {
              if (modalRes.confirm) {
                // 🔥 调用融云IM清空消息（使用手机号作为targetId）
                const targetId = this.data.friendPhone || String(this.data.friendId);
                rongcloud.clearMessages(targetId)
                  .then(() => {
                    // 🔥 同时清空本地存储（本地存储使用数据库ID）
                    messageStorage.clearChatMessages(String(this.data.friendId));
                    
                    this.setData({
                      messages: []
                    });
                    wx.showToast({
                      title: '已清空',
                      icon: 'success'
                    });
                  })
                  .catch((error) => {
                    console.error('❌ 清空失败:', error);
                    // 即使融云清空失败，也尝试清空本地存储
                    messageStorage.clearChatMessages(String(this.data.friendId));
                    this.setData({
                      messages: []
                    });
                    wx.showToast({
                      title: '已清空本地记录',
                      icon: 'success'
                    });
                  });
              }
              }
            });
            break;
          case 2:
            // 删除好友
            console.log('❌ 删除好友');
            wx.showModal({
              title: '提示',
              content: '确定要删除该好友吗？',
              success: (modalRes) => {
                if (modalRes.confirm) {
                  // TODO: 调用删除好友接口
                  wx.showToast({
                    title: '功能开发中',
                    icon: 'none'
                  });
                }
              }
            });
            break;
        }
      }
    });
  },

  // 返回上一页
  onBack() {
    wx.navigateBack();
  },

  /**
   * 🔥 点击对方头像 - 跳转到好友的用户主页
   */
  onFriendAvatarTap() {
    console.log('🖼️ =============== 点击对方头像 ===============');
    console.log('👤 好友ID:', this.data.friendId);
    console.log('👤 好友名称:', this.data.friendName);
    
    if (!this.data.friendId) {
      wx.showToast({
        title: '用户信息不完整',
        icon: 'none',
        duration: 2000
      });
      return;
    }
    
    // 跳转到用户主页，传递好友ID
    wx.navigateTo({
      url: `/pages/user-info/index?userId=${this.data.friendId}`,
      success: () => {
        console.log('✅ 跳转到好友主页成功');
      },
      fail: (err) => {
        console.error('❌ 跳转失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        });
      }
    });
  },

  /**
   * 🔥 点击自己头像 - 跳转到自己的用户主页
   */
  onMyAvatarTap() {
    console.log('🖼️ =============== 点击自己头像 ===============');
    console.log('👤 当前用户ID:', this.data.currentUserId);
    
    // 跳转到用户主页（不传userId参数则显示自己的主页）
    wx.navigateTo({
      url: '/pages/user-info/index',
      success: () => {
        console.log('✅ 跳转到自己主页成功');
      },
      fail: (err) => {
        console.error('❌ 跳转失败:', err);
        wx.showToast({
          title: '跳转失败',
          icon: 'none'
        });
      }
    });
  },

  onShow() {
    console.log('👀 聊天页面显示');
    console.log('👤 当前聊天好友ID:', this.data.friendId);
    console.log('👤 当前聊天好友名称:', this.data.friendName);
    
    // 🔥 移除旧的监听器（如果存在），避免重复添加
    if (this.messageListener) {
      console.log('⚠️ 检测到旧监听器，先移除');
      rongcloud.removeMessageListener(this.messageListener);
      this.messageListener = null;
    }
    
    if (this.connectionListener) {
      console.log('⚠️ 检测到旧连接监听器，先移除');
      rongcloud.removeConnectionListener(this.connectionListener);
      this.connectionListener = null;
    }
    
    // 🔥 添加融云消息监听器（使用统一的消息处理）
    this.messageListener = (message) => {
      console.log('📨 =============== 聊天页面收到新消息 ===============');
      console.log('📦 消息详情:', message);
      
      // 🔥 判断是否是当前会话的消息
      const isPrivateChat = message.conversationType === 1; // 1 = PRIVATE 单聊
      
      // 🔥 正确的判断逻辑：
      // 在融云单聊中：
      // - senderUserId: 发送者的ID
      // - targetId: 会话对象的ID（单聊中就是对方的ID）
      // 
      // 好友发消息给我：
      // - senderUserId = 好友手机号
      // - targetId = 好友手机号（会话对象）
      const isFromCurrentFriend = message.senderUserId === String(this.data.friendPhone);
      const isThisConversation = message.targetId === String(this.data.friendPhone);
      
      console.log('🔍 消息过滤检查:');
      console.log('  - 是否私聊:', isPrivateChat);
      console.log('  - 发送者ID:', message.senderUserId);
      console.log('  - 会话对象ID:', message.targetId);
      console.log('  - 好友手机号:', this.data.friendPhone);
      console.log('  - 是否来自当前好友:', isFromCurrentFriend);
      console.log('  - 是否当前会话:', isThisConversation);
      
      if (isPrivateChat && isFromCurrentFriend && isThisConversation) {
        console.log('✅ 消息属于当前会话');
        
        try {
          // 🔥 直接转换消息格式（不依赖 processAndSaveRongCloudMessage）
          // 因为 app.js 的全局监听器已经保存了消息，这里只需要添加到UI
          console.log('🔄 开始转换消息格式...');
          console.log('📦 message.messageId:', message.messageId);
          console.log('📦 message.content:', message.content);
          console.log('📦 message.sentTime:', message.sentTime);
          
          const newMessage = {
            id: message.messageId,
            content: message.content.content || message.content.text || '[无法显示的消息]',
            isSelf: false,
            time: this.formatMessageTimeFromTimestamp(message.sentTime),
            sentTime: message.sentTime,
            messageType: message.messageType
          };
          
          console.log('✅ 消息格式转换完成:', newMessage);
          console.log('📊 当前消息列表长度:', this.data.messages.length);
          
          // 检查是否重复（避免重复显示）
          console.log('🔍 开始检查消息是否重复...');
          const isDuplicate = this.data.messages.some(msg => {
            const idMatch = msg.id === newMessage.id;
            const contentMatch = msg.content === newMessage.content;
            const timeDiff = Math.abs(msg.sentTime - newMessage.sentTime);
            const timeMatch = timeDiff < 1000;
            
            if (idMatch) {
              console.log('   🔍 发现ID重复:', msg.id);
            }
            if (contentMatch && timeMatch) {
              console.log('   🔍 发现内容+时间重复:', msg.content, '时间差:', timeDiff);
            }
            
            return idMatch || (contentMatch && timeMatch);
          });
          
          console.log('🔍 重复检查结果:', isDuplicate);
          
          if (isDuplicate) {
            console.log('⚠️ 消息重复，跳过添加到UI');
            return;
          }
          
          // 添加到UI
          console.log('🎨 准备添加消息到UI...');
          const messages = [...this.data.messages, newMessage];
          console.log('🎨 新消息列表长度:', messages.length);
          
          this.setData({
            messages: messages
          });
          
          console.log('✅ setData 完成');
          
          // 滚动到底部
          this.scrollToBottom();
          
          console.log('✅ 新消息已添加到UI');
        } catch (error) {
          console.error('❌ 添加消息到UI失败:', error);
          console.error('错误堆栈:', error.stack);
        }
      } else {
        console.log('❌ 消息不属于当前会话，忽略');
      }
    };
    
    rongcloud.addMessageListener(this.messageListener);
    
    // 🔥 添加融云连接状态监听器
    this.connectionListener = (connected) => {
      console.log('🔔 连接状态变化:', connected ? '已连接' : '已断开');
      
      this.setData({
        isConnected: connected
      });
      
      // 如果连接成功，重新加载消息
      if (connected && this.data.messages.length === 0) {
        this.loadMessages();
      }
    };
    
    rongcloud.addConnectionListener(this.connectionListener);
    
    // 检查当前连接状态
    const isConnected = rongcloud.getConnectionStatus();
    this.setData({ isConnected });
    
    console.log('✅ 消息监听器已设置');
  },

  onHide() {
    console.log('👋 聊天页面隐藏');
    
    // 🔥 移除监听器，避免页面隐藏时继续处理消息
    if (this.messageListener) {
      console.log('🔇 移除消息监听器（页面隐藏）');
      rongcloud.removeMessageListener(this.messageListener);
      this.messageListener = null;
    }
    
    if (this.connectionListener) {
      console.log('🔇 移除连接监听器（页面隐藏）');
      rongcloud.removeConnectionListener(this.connectionListener);
      this.connectionListener = null;
    }
  },

  onUnload() {
    console.log('💾 聊天页面卸载');
    
    // 🔥 移除融云消息监听器
    if (this.messageListener) {
      rongcloud.removeMessageListener(this.messageListener);
      this.messageListener = null;
    }
    
    // 🔥 移除融云连接状态监听器
    if (this.connectionListener) {
      rongcloud.removeConnectionListener(this.connectionListener);
      this.connectionListener = null;
    }
    
    console.log('✅ 已移除所有监听器');
  }
});

